﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.IO;
using vudu.ClasesDominio;
using vudu.Logica.Comandos;
using vudu.Logica.Comandos.VU_08;
using vudu.Logica.Comandos.VU_08_Gestionar_Notas_de_Estudiantes;
using vudu.Logica.Fabrica;
using vudu.Logica.IComandos;
using vudu.Logica.Clases;// mientras migran a ClasesDominio las clases de HorarioDeClase y Salon
using vudu.Logica.Excepciones;
using System.Data;
using System.Data.SqlClient;

namespace vudu.Logica.Fachada
{
    public class EnlaceLogico
    {
        private Rol miRol;

        public EnlaceLogico()
        {
           // miRol = new Rol(); No se puede ya que la Clase Rol es Abstracta
        }

        public Rol RolActual
        {
            get { return miRol; }
            set { miRol = value; }
        }

        private Rol usuarioActual;

        public Rol UsuarioActual
        {
            get { return usuarioActual; }
            set { usuarioActual = value; }
        }

        #region VU_1 Gestionar Salones

        public int AgregarSalon(Salon miSalon, int universidad)
        {
            Comando<int> comando = FabricaComando.CrearComandoAgregarSalon(miSalon, universidad);
            return comando.Ejecutar();
        }

        public int EliminarSalon(Salon miSalon)
        {
            Comando<int> comando = FabricaComando.CrearComandoEliminarSalon(miSalon);
            return comando.Ejecutar();
        }

        public int ModificarSalon(Salon miSalon, int universidad)
        {
            Comando<int> comando = FabricaComando.CrearComandoModificarSalon(miSalon, universidad);
            return comando.Ejecutar();
        }

        public List<Salon> ConsultarSalon(int opcion,string busqueda,Universidad universidad)
        {
            Comando<List<Salon>> comando = FabricaComando.CrearComandoConsultarSalon(opcion, busqueda, universidad);
            return comando.Ejecutar();
        }

        public Boolean AgregarEnBD(String salon)
        {
            return true;
        }

        public List<String> CargarSalonesEnSistemas()
        {
            return null;
        }

        public String CargarInfoSalon(int _numeroSalon)
        {
            return null;
        }

        public Boolean ModificarSalonEnBD(String salon)
        {
            return false;
        }

        public void CambiarStatusSalon(string _nombre)
        {
        }

        public List<Edificio> ConsultarEdificios(int idUniversidad)
        {
            Comando<List<Edificio>> comando = FabricaComando.CrearComandoConsultarEdificios(idUniversidad);
            return comando.Ejecutar();
        }

        #endregion VU_1 Gestionar Salones

        #region VU_2 Gestionar Escuelas

        public int AgregarEscuela(Escuela nuevaEscuela, String universidad)
        {
            Comando<int> comando = FabricaComando.CrearComandoAgregarEscuela(nuevaEscuela,universidad);
            return comando.Ejecutar();
        }

        public List<Escuela> ConsultarListaEscuela(String universidad)
        {
            Comando<List<Escuela>> comando = FabricaComando.CrearComandoConsultarEscuela(universidad);
            return comando.Ejecutar();
        }

        public int ModificarEscuela(Escuela nuevaEscuela, String universidad)
        {
            Comando<int> comando = FabricaComando.CrearComandoModificarEscuela(nuevaEscuela, universidad);
            return comando.Ejecutar();
        }

        public bool EliminarEscuela(int escuela)
        {
            Comando<bool> comando = FabricaComando.CrearComandoEliminarEscuela(escuela);
            return comando.Ejecutar();
        }

        #endregion VU_2 Gestionar Escuelas

        #region VU_3 Gestionar Pensum de cada Escuela


        public List<Escuela> ConsultarEscuelasVecinas(int idEscuela)
        {

            //aqui uso comando
            Comando<List<Escuela>> comando = FabricaComando.CrearComandoConsultarEscuelaVecinas(idEscuela);
            return comando.Ejecutar();

        }

        public List<Materia> ConsultarMateriasDeEscuela(int idEscuela)
        {

            //aqui uso al comando
            Comando<List<Materia>> comando = FabricaComando.CrearComandoConsultarMateriasDeEscuela(idEscuela);
            return comando.Ejecutar();
        }

        public int CrearPensum(Pensum nuevoPensum)
        {
            Comando<int> comando = FabricaComando.CrearComandoCrearPensum(nuevoPensum);
            return comando.Ejecutar();

        }

        public List<Pensum> ConsultarPensumsArchivadosDeEscuela(Escuela esc, int tipoConsulta)
        {
            Comando<List<Pensum>> comando = FabricaComando.CrearComandoConsultarPensumsArchivadosDeEscuela(esc, tipoConsulta);
            return comando.Ejecutar();
        }

        public List<Pensum> ConsultarPensumsInactivosDeEscuela(Escuela esc, int tipoConsulta)
        {
            Comando<List<Pensum>> comando = FabricaComando.CrearComandoConsultarPensumsArchivadosDeEscuela(esc,  tipoConsulta);
            return comando.Ejecutar();
        }

        public List<Prelacion> ConsultarMateriasDeUnPensum(int idPensum)
        {
            Comando<List<Prelacion>> comando = FabricaComando.CrearComandoConsultarMateriasDePensum(idPensum);
            return comando.Ejecutar();
        }

        public List<Materia> ConsultarPrelacionesDeMateria(int idPensum, int codigoMateria)
        {
            Comando<List<Materia>> comando = FabricaComando.CrearComandoConsultarPrelacionesDeMateria(idPensum, codigoMateria);
            return comando.Ejecutar();
        }

        public bool InsertarMateriaSemestre(Pensum pensum, List<Prelacion> semestre)
        {
            Comando<bool> comando = FabricaComando.CrearComandoAgregarMateriaEnPensum(pensum, semestre);
            return comando.Ejecutar();
        }

        public bool InsertarPrelacionesDeMateria(Materia materia, List<Materia> prelaciones, Pensum pensum)
        {
            Comando<bool> comando = FabricaComando.CrearComandoAgregarPrelacionesDeMateria(materia, prelaciones, pensum);
            return comando.Ejecutar();
        }

        public List<Prelacion> ConsultarMateriasDePensumPorSemestre(Pensum pensum, int numeroSemestre)
        {
            Comando<List<Prelacion>> comando = FabricaComando.CrearComandoConsultarMateriasDePensumPorSemestre(pensum, numeroSemestre);
            return comando.Ejecutar();
            
        }

        public List<Prelacion> ConsultarMateriasDeSemestresInferiores(Pensum pensum, int numeroSemestre, Materia materia)
        {
            Comando <List< Prelacion >> comando = FabricaComando.CrearComandoConsultarMateriasSemestresInferiores(pensum, numeroSemestre, materia);
            return comando.Ejecutar();

        }

        public bool EliminarPensumInactivo(int idPensum)
        {
            Comando<bool> comando = FabricaComando.CrearComandoEliminarPensum(idPensum);
            return comando.Ejecutar();
        }

        public Pensum ConsultarPensumActivo(int idEscuela)
        {
            Comando<Pensum> comando = FabricaComando.CrearComandoConsultarPensumActivo(idEscuela);
            return comando.Ejecutar();
        }

        public bool ArchivarPensum(int idPensum)
        {
            Comando<bool> comando = FabricaComando.CrearComandoArchivarPensum(idPensum);
            return comando.Ejecutar();
        }

        public int ConsultarPeriodoActual()
        {
            Comando<int> comando = FabricaComando.CrearComandoConsultarPeriodoAcademico();
            return comando.Ejecutar();
        }

        public bool ActivarPensum(int idPensum, int idPeriodo)
        {
            Comando<bool> comando = FabricaComando.CrearComandoActivarPensum(idPensum, idPeriodo);
            return comando.Ejecutar();
        }

        public bool EliminarPrelacion(Materia materiaActual, List<Materia> materiaPrelacion, Pensum pensum)
        {
            Comando<bool> comando = FabricaComando.CrearComandoEliminarPrelacion(materiaActual, materiaPrelacion, pensum);
            return comando.Ejecutar();
        }

        public bool EliminarMateriaDePensum(List<Materia> materiaActual, Pensum pensum)
        {
            Comando<bool> comando = FabricaComando.CrearComandoEliminarMateriaPensum(materiaActual, pensum);
            return comando.Ejecutar();
        }

        public List<Materia> ConsultarMateriaEscuelaG3(int idEscuela)
        {
            Comando<List<Materia>> comando = FabricaComando.CrearComandoG3MateriaEscuela(idEscuela);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarMateriaSeccionG3(int idEscuela)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarMateriaSeccionG3(idEscuela);
            return comando.Ejecutar();
        }

        public List<Estudiante> ConsultarEstudiantesSeccion(int idSeccion)
        {
            Comando<List<Estudiante>> comando = FabricaComando.CrearComandoConsultarEstudiantesSeccionG3(idSeccion);
            return comando.Ejecutar();
        }

        #endregion VU_3 Gestionar Pensum de cada Escuela

        #region VU_4 Gestionar Materias

        /* public int AgregarMateria(Materia materia, int idEscuela)
        {
            ComandoAgregarMateria comando = FabricaComando.CrearComandoAgregarMateria(materia, idEscuela);
            return comando.Ejecutar();
        }

        public int EliminarMateria(int idMateria)
        {
            ComandoEliminarMateria comando = FabricaComando.CrearComandoEliminarMateria(idMateria);
            return comando.Ejecutar();
        }

        public int ModificarMateria(Materia materia)
        {
            ComandoEditarMateria comando = FabricaComando.CrearComandoEditarMateria(materia);
            return comando.Ejecutar();
        }

        
        public List<Materia> ConsultarMateriasEscuela(int idEscuela)
        {
            ComandoConsultarMateriasEscuela comando = FabricaComando.CrearComandoConsultarMateriasEscuela(idEscuela);
            return comando.Ejecutar();

        }
        */

        public String ConsultarMateria(String nombre, int tipo)
        {
            return null;
        }

        /// <summary>
        /// Metodo que retorna una lista de todas las materias
        /// </summary>
        /// <returns></returns>
        public List<Materia> ConsultarMaterias()
        {
            Comando<List<Materia>> comando = FabricaComando.CrearComandoConsultarTodasMateria();
            return comando.Ejecutar();
        }

        #endregion VU_4 Gestionar Materias

        #region VU_5 Gestionar Practicas por Materia


            //Dado los datos solicitados en la vista, se llama a esta funcion para guardar la practica
            //en la base de datos.
            public bool CrearPractica(Practica miPractica, int idSeccionMateria)
            {
                Comando<bool> comando = FabricaComando.CrearComandoAgregarPractica( miPractica, idSeccionMateria);
                return comando.Ejecutar();
		    }
        
            //Esta funcion nos regresa el las materias activas dependiendo de la escuela que las solicite.
            public List<Materia> ObtenerMateriasActivasConSeccTeoria(string nombreEscuela)
            {
                Comando<List<Materia>> comando = FabricaComando.CrearComandoObtenerMateriasActivasConSeccTeoria(nombreEscuela);
                return comando.Ejecutar();
            }
    
            //Dependiendo del rol, usamos el correo del mismo apra identificar la escuela que solicita el acceso
            // y asi construir el objeto de la escula.
            public Escuela ArmarEscuela(string correoEscuela)
            {
                Comando<Escuela> comando = FabricaComando.CrearComandoArmarEscuela(correoEscuela);
                return comando.Ejecutar();
            }

            //Sabiendo la materia y la escuela a la que pertenece, con esta funcion podemos obtener las secciones
            //disponibles para poder crear una practica.
            public List<SeccionMateria> ArmarListaDeSeccionesDisponibles(int idEscuela,int idMateria)
            {
                Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoArmarListaDeSeccionesDisponibles(idEscuela, idMateria);
                return comando.Ejecutar();
            }

            //regresa la lista de profesores que pueden dar la materia.
            public List<Profesor> ConsultarProfesores(int idEscuela)
            {
                Comando<List<Profesor>> comando = FabricaComando.CrearComandoConsultarProfesores(idEscuela);
                return comando.Ejecutar();
            }

            //regresa la lista de salones disponibles para una hora determinada
            public List<Salon> ListaSalonesDisponibles(HorarioDeClase horario, string nombreEscuela, int idEscuela, int idProfesor)
            {
                Comando<List<Salon>> comando = FabricaComando.CrearComandoListaSalonesDisponibles(horario, nombreEscuela, idEscuela, idProfesor);
                return comando.Ejecutar();
            }
      
            //cada seccion tiene practicas, y con esta funcion obtenemos todas las prracticas de dicha seccion
            public List<Practica> ConsultarPracticasDadaSeccionMateria(int idSeccionMateria)
            {
                Comando<List<Practica>> comando = FabricaComando.CrearComandoConsultarPracticasDadaSeccionMateria(idSeccionMateria);
                return comando.Ejecutar();
            }

            //Esta funcion desactiva una practica, cambia el status de Activo a Inactivo
            public bool EliminarPractica(int idPractica)
            {
                Comando<bool> comando = FabricaComando.CrearComandoEliminarPractica(idPractica);
                return comando.Ejecutar();
            }

            //Esta funcion regresa la lista de horarios que tiene una practica determinada
            public List<HorarioDeClase> ConsultarPractica(int idPractica)
            {
                Comando<List<HorarioDeClase>> comando = FabricaComando.CrearComandoConsultarPractica(idPractica);
                return comando.Ejecutar();
            }

            //si en la vista se modifican los datos de una practica, esta funcion refleja dichos cambios en la base de datos
            public bool ModificarPractica(Practica miPractica)
            {
                Comando<bool> comando = FabricaComando.CrearComandoModificarPractica(miPractica);
                return comando.Ejecutar();
            }

            //Esta funcion nos regresa las secciones y las practicas de una escuela.
            public List<Materia> ConsultarListaMateriasConPractica( string nombreEscuela )
            {
                Comando<List<Materia>> comando = FabricaComando.CrearComandoConsultarListaMateriasConPractica(nombreEscuela);
                return comando.Ejecutar();
            }


        #endregion VU_5 Gestionar Practicas por Materia

        #region VU_6 Gestionar Profesores

        public int EnlaceAgregarProfesor(Profesor profesor, int idEscuela)
        {
            ComandoAgregarProfesor comando = FabricaComando.CrearComandoAgregarProfesor(profesor, idEscuela);
            return comando.Ejecutar();
        }

        public bool EnlaceLogicoEliminarProfesor(int idProfesor, int idEscuela)
        {
            ComandoEliminarProfesor comando = FabricaComando.CrearComandoEliminarProfesor(idProfesor, idEscuela);
            return comando.Ejecutar();

        }

        public int EnlaceModificarProfesor(Profesor profesor, int idEscuela)
        {
            ComandoModificarProfesor comando = FabricaComando.CrearComandoModifcarProfesor(profesor, idEscuela);
            return comando.Ejecutar();
        }

        public List<Profesor> consultarProfesores(int idEscuela)
        {
            ComandoConsultarProfesoresEscuela comando = 
                FabricaComando.CrearComandoConsultarProfesoresEscuela(idEscuela);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> MateriasAsignadasProfesor (int idProfesor, int idEscuela)
        {
            ComandoMateriasAsignadasProfesor comando = 
                FabricaComando.CrearComandoMateriasAsignadas(idProfesor, idEscuela);
            return comando.Ejecutar();
        }

        public Profesor EnlaceConsultarProfesorExistente(int idCedula, int idEscuela)
        {
            ComandoConsultarProfesorExistente comando =
                FabricaComando.CrearComandoConsultarProfesorExistente(idCedula, idEscuela);
            return comando.Ejecutar();
        }

        public int EnlaceAgregarProfesorExistente(Profesor profesor, int idProfesor)
        {
            ComandoAgregarProfesorExistente comando =
                FabricaComando.CrearComandoAgregarProfesorExistente(profesor, idProfesor);
            return comando.Ejecutar();
        }
        
        public List<Materia> EnlaceLogicoConsultarMateriaEscuela(int idEscuela)
        {
            ComandoConsultarMateriaEscuela comando =
                FabricaComando.CrearComandoConsultarMateriaEscuela(idEscuela);
            return comando.Ejecutar();
        }
        
        //Consulta los profesores existentes que tienen asignada una materia en la escuela que inicio session
        public List<Profesor> EnlaceLogicoConsultarProfesorPorEscuelaMateria(int idEscuela, string nombreMateria)
        {
            ComandoConsultarProfesoresPorEscuelaMateria comando =
                FabricaComando.CrearComandoConsultarProfesoresPorEscuelaMateria(idEscuela, nombreMateria);
            return comando.Ejecutar();
        }

        public int EnlaceLogicoModificarPerfilProfesor(Profesor profesor)
        {
            ComandoModificarPerfilProfesor comando =
                FabricaComando.CrearComandoModificarMiPerfilProfesor(profesor);
            return comando.Ejecutar();
        } 

        #endregion VU_6 Gestionar Profesores

        #region VU_7 Gestionar Esquema de Evaluacion por Profesor

        public List<SeccionMateria> ConsultarSeccionesProfesor(Profesor profesor)
        {
            Comando<List<SeccionMateria>> miComando = FabricaComando.CrearComandoLlenarComboMateriasProfesor(profesor);
            return miComando.Ejecutar();
        }

        public List<Evaluacion> ConsultarEvaluacionPorSeccion(SeccionMateria seccion)
        {
            Comando<List<Evaluacion>> miComando = FabricaComando.CrearComandoCargarTablaEsquemaEvaluacion(seccion);
            return miComando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarEsquemasDeEvaluacionSinNotasProfesor(Profesor profesor)
        {
            Comando<List<SeccionMateria>> miComando = FabricaComando.CrearComandoLlenarListaEsquemaEvaluacionSinNotas(profesor);
            return miComando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarEsquemasDeEvaluacionProfesor(Profesor profesor)
        {
            Comando<List<SeccionMateria>> miComando = FabricaComando.CrearComandoLlenarListaSeccionesEsquemaEvaluacionProfesor(profesor);
            return miComando.Ejecutar();
        }

        /// <summary>
        /// Metodo que consulta todas las evaluacion de una seccion materia
        /// </summary>
        /// <param name="seccionMateria"></param>
        /// <returns></returns>
        public List<Evaluacion> ConsultarEsquemaEvaluacionSeccion(SeccionMateria seccionMateria)
        {
            Comando<List<Evaluacion>> comando =
                FabricaComando.CrearComandoConsultarMateriaSeccionEvaluacion(seccionMateria);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarEsquemasEvaluacionEstudiante(Estudiante estudiante)
        {
            Comando<List<SeccionMateria>> miComando = FabricaComando.CrearComandoLlenarListaSeccionesEsquemaEvaluacionEstudiante(estudiante);
            return miComando.Ejecutar();
        }

        public int InsertarEvaluacion(Evaluacion evaluacion)
        {
            Comando<int> miComando = FabricaComando.CrearComandoAgregarEsquemaEvaluacion(evaluacion);
            return miComando.Ejecutar();
        }

        public bool EliminarEsquemaDeEvaluacion(SeccionMateria seccionMateria)
        {
            Comando<bool> miComando = FabricaComando.CrearComandoEliminarEsquemaEvaluacion(seccionMateria);
            return miComando.Ejecutar();
        }

        public bool ModificarEvaluacion(Evaluacion evaluacion)
        {
            Comando<bool> miComando = FabricaComando.CrearComandoModificarEsquemaEvaluacion(evaluacion);
            return miComando.Ejecutar();
        }

        #endregion VU_7 Gestionar Gestionar Esquema de Evaluacion por Profesor

        #region VU_8 Gestionar Notas de Estudiante

        /// <summary>
        /// Metodo que retorna la nota de un estudiante de una evaluacion
        /// </summary>
        /// <param name="idEvaluacion"></param>
        /// <param name="idEstudiante"></param>
        /// <returns></returns>
        public Nota ConsultarNotaEstudianteEvaluacion(int idEvaluacion, int idEstudiante)
        {
            ComandoConsultarNotaEstudiante comando = FabricaComando.CrearComandoConsultarNotaEstudiante(idEvaluacion, idEstudiante);
            return comando.Ejecutar();
        }

        /// <summary>
        /// Metodo que invoca los comando necesarios para insertar una nota
        /// </summary>
        /// <param name="nota"></param>
        /// <returns></returns>
        public int IngresarNota(Nota nota)
        {
            Comando<int> comando = FabricaComando.CrearComandoInsertarNota(nota);
            return comando.Ejecutar();
        }

        /// <summary>
        /// Metodo que edita los datos de una nota
        /// </summary>
        /// <param name="nota"></param>
        /// <returns></returns>
        public bool EditarNota(Nota nota)
        {
            Comando<bool> comando = FabricaComando.CrearComandoEditarNota(nota);
            return comando.Ejecutar();
        }

        /// <summary>
        /// Metodo que consulta todas las materias de un profesor en el periodo academico
        /// </summary>
        /// <param name="profesor"></param>
        /// <returns></returns>
        public List<SeccionMateria> ConsultarMateriaProfesorPeriodo(Profesor profesor)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.ConsultarMateriaProfesorPeriodo(profesor);
            return comando.Ejecutar();
        } 
        #endregion VU_8 Gestionar Notas de Estudiante

        #region VU_9 Gestionar la Carga de Archivos PDF

        public List<Universidad> ConsultarUniversidadesProfesor(int idProfesor)
        {
            Comando<List<Universidad>> comando = FabricaComando.CrearComandoConsultarUniversidades(idProfesor);
            return comando.Ejecutar();
        }

        public List<Escuela> ConsultarEscuelasProfesor(string nombreUniv, int idProfesor)
        {
            Comando<List<Escuela>> comando = FabricaComando.CrearComandoConsultarEscuelas(nombreUniv, idProfesor);
            return comando.Ejecutar();
        }
        public List<Materia> ConsultarMateriasProfesorPdf(int idProfesor, string nombreUniv, string nombreEscuela)
        {
            Comando<List<Materia>> comando = FabricaComando.CrearComandoConsultarMateriasProfesorPdf(idProfesor, nombreUniv, nombreEscuela);
            return comando.Ejecutar();
        }
        public List<SeccionMateria> ConsultarSeccionesProfesorPdf(int idProfesor,string nombreUniv, string nombreEscuela, string nombreMateria)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarSeccionesProfesorPdf(idProfesor, nombreUniv, nombreEscuela, nombreMateria);
            return comando.Ejecutar();
        }
        public DataTable ConsultarArchivoProfesor(int crn, int seccion)
        {
            Comando<DataTable> comando = FabricaComando.CrearComandoConsultarArchivoProfesor(crn, seccion);
            return comando.Ejecutar();
        }
        
        public FileInfo buscarRuta(List<String> miOperacion, int idComparar)
        {
            return null;
        }

        public List<Categoria> ConsultarCategorias(int idProfesor, int idSeccion)
        {
            Comando<List<Categoria>> comando = FabricaComando.CrearComandoConsultarCategorias(idProfesor, idSeccion);
            return comando.Ejecutar();
        }
        public List<OperacionesPdf> ConsultarArchivos(int idProfesor, int idSeccion, String categoria)
        {
            Comando<List<OperacionesPdf>> comando = FabricaComando.CrearComandoConsultarArchivos(idSeccion, idProfesor, categoria);
            return comando.Ejecutar();
        }

        public bool InsertarArchivoPdf(OperacionesPdf archivoPdf, float tamañoArchivo,int crn, int idSeccion)
        {
            Comando<bool> comando = FabricaComando.CrearComandoInsertarArchivoPdf(archivoPdf, tamañoArchivo, crn, idSeccion);
            return comando.Ejecutar();
        }

        public List<Categoria> ConsultarAllCategorias()
        {
            Comando<List<Categoria>> comando = FabricaComando.CrearComandoConsultarAllCategorias();
            return comando.Ejecutar();
        }

        public bool EliminarArchivo(OperacionesPdf miArchivo, int idSeccion)
        {
            Comando<bool> comando = FabricaComando.crearComandoEliminarArchivoPdf(miArchivo, idSeccion);
            return comando.Ejecutar();
        }
        

        public List<SeccionMateria> ConsultarSeccionesEstudianteArchivoPdf(Estudiante estudiante)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarSeccionesEstudianteArchivoPdf(estudiante);
            return comando.Ejecutar();
        }
        public DataTable ConsultarArchivoEstudiante(int seccion)
        {
            Comando<DataTable> comando = FabricaComando.CrearComandoConsultarArchivoEstudiante(seccion);
            return comando.Ejecutar();
        }
        #endregion VU_9 Gestionar la Carga de Archivos PDF

        #region VU_10 Consultar Horarios de Materias e Imprimir


        public List<SeccionMateria> MateriasEstudianteHorario(int estudiante)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarMateriasDeEstudiante(estudiante);
            return comando.Ejecutar();
        }

        public List<Practica> PracticasEstudianteHorario(int estudiante)
        {
            Comando<List<Practica>> comando = FabricaComando.CrearComandoConsultarPracticasDeEstudiante(estudiante);
            return comando.Ejecutar();
        }

        public List<HorarioDeClase> HorarioDeMateria(SeccionMateria seccion)
        {
            Comando<List<HorarioDeClase>> comando = FabricaComando.CrearComandoConsultarHorarioDeMateriaEstudiante(seccion);
            return comando.Ejecutar();
        }

        public List<HorarioDeClase> HorarioDePractica(Practica seccion)
        {
            Comando<List<HorarioDeClase>> comando = FabricaComando.CrearComandoConsultarHorarioDePracticaEstudiante(seccion);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> MateriasProfesorHorario(int profesor)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarMateriasDeProfesor(profesor);
            return comando.Ejecutar();
        }

        public List<Practica> MateriasPracticaProfesor(int profesor)
        {
            Comando<List<Practica>> comando = FabricaComando.CrearComandoConsultarPracticaProfesor(profesor);
            return comando.Ejecutar();
        }

        public List<HorarioDeClase> HorarioDeMateriaProfesor(SeccionMateria seccion)
        {
           Comando<List<HorarioDeClase>> comando = FabricaComando.CrearComandoConsultarHorarioDeMateriaProfesor(seccion);
            return comando.Ejecutar();
        }

        public List<HorarioDeClase> HorarioDePracticaProfesor(Practica seccion)
        {
            Comando<List<HorarioDeClase>> comando = FabricaComando.CrearComandoConsultarHorarioDePracticaProfesor(seccion);
            return comando.Ejecutar();
        }

        public String NombreDeEscuela(String NombreMateria) 
        {
            Comando<String> comando = FabricaComando.CrearComandoNombreDeLaEscuela(NombreMateria);
            return comando.Ejecutar();
        }

        public String NombreDeUniversidad(String NombreMateria)
        {
            Comando<String> comando = FabricaComando.CrearComandoNombreDeLaUniversidad(NombreMateria);
            return comando.Ejecutar();
        }

        public List<String> NombreDeEscuelaUniversidad(int idPractica)
        {
            Comando<List<String>> comando = FabricaComando.CrearComandoNombreEscuelaUniversidad(idPractica);
            return comando.Ejecutar();
        }

        private bool MostrarInfoSalon()
        {
            return true;
        }

        public String AgregarSalon(String nombreSalon)
        {
            return null;
        }

        public List<String> SalonesDisponibles(int horaInicioP, int horaFinP, String diaP, int idEscuela)
        {
            return null;
        }


        public List<String> CargarHorario(String dia)
        {
            return null;
        }

        public List<String> CompararSalones(List<String> salonNoDisponible, List<String> salonesTotal)
        {
            return null;
        }

        public List<String> listaSalonesOcupados(int horaInicioP, int horaFinP, List<String> listaHorario)
        {
            return null;
        }
       
        public void crearHorario()
        {
        }

        #endregion VU_10 Consultar Horarios de Materias e Imprimir

        #region VU_11 Consultar Estudiantes por Seccion e Imprimir

        /// <summary>
        /// Metodo que consulta todos los estudiantes de una seccion
        /// </summary>
        /// <param name="seccion"></param>
        /// <returns></returns>
        public List<Estudiante> ConsultarEstudiantesSeccion(SeccionMateria seccion)
        {
            ComandoConsultarAlumnosSeccion comando = FabricaComando.CrearComandoConsultarAlumnosSeccion(seccion);
            return comando.Ejecutar();
        }

        #endregion VU_11 Consultar Estudiantes por Seccion e Imprimir

        #region VU_12 Obtener reportes de Material

        public List<SeccionMateria> ConsultarMateriasSeccionProfesor(int idProfesor)
        {
            ComandoConsultarReporteMaterial comando = FabricaComando.CrearComandoConsultarReporteMaterial(idProfesor);
            return comando.Ejecutar();
        }

        public List<Evaluacion> ConsultarEvaluacionesMateriaProfesor(int idSeccion)
        {
            ComandoConsultarEvaluacionesSeccionMateriaProfesor comando = FabricaComando.CrearComandoConsultarReporteEvaluacionesMaterial(idSeccion);
            return comando.Ejecutar();
        }

        #endregion VU_12 Obtener reportes de Material

        #region VU_13 Gestionar Horarios
        public List<Materia> ConsultarMateriasPrematricula(Estudiante estudiante, int semestreActual)
        {
            ComandoConsultarMateriasPrematricula comando = FabricaComando.CrearComandoConsultarMateriasPrematricula(estudiante,semestreActual);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarSeccionesDeUnaMateria(Materia materia)
        {
            ComandoConsultarSeccionesDeUnaMateria comando = FabricaComando.CrearComandoConsultarSeccionesDeUnaMateria(materia);
            return comando.Ejecutar();
        }

        public List<HorarioDeClase> ConsultarHorarioDeClaseSeccion(SeccionMateria seccionMateria)
        {
            ComandoConsultarHorarioDeClaseSeccion comando =
                FabricaComando.CrearComandoConsultarHorarioDeClaseSeccion(seccionMateria);
            return comando.Ejecutar();
        }
        public List<Prematricula> ConsultarPrematriculas(Estudiante estudiante)
        {
            ComandoConsultarPrematricula comando = FabricaComando.CrearComandoConsultarPrematricula(estudiante);
            return comando.Ejecutar();
        }
        public int InsertarPrematricula (Prematricula prematricula)
        {
            ComandoInsertarPrematricula comando = FabricaComando.CrearComandoInsertarPrematricula(prematricula);
            return comando.Ejecutar();
        }
        public bool InsertarPrematriculaSeccionMateria(int fkPrematricula, int fkPractica, int fkSeccionMateria)
        {
            ComandoInsertarPrematriculaSeccionMateria comando =
                FabricaComando.CrearComandoInsertarPrematriculaSeccionMateria(fkPrematricula, fkPractica,
                                                                              fkSeccionMateria);
            return comando.Ejecutar();
        }
        public Estudiante ConsultarInformacionEstudiante (Estudiante estudiante)
        {
            ComandoConsultarInformacionEstudiante comando = FabricaComando.CrearComandoConsultarInformacionEstudiante(estudiante);
            return comando.Ejecutar();
        }
        public bool EliminarPrematricula(Prematricula prematricula)
        {
            ComandoEliminarPrematricula comando = FabricaComando.CrearComandoEliminarPrematricula(prematricula);
            return comando.Ejecutar();
        }
        public bool AprobarPrematricula(Prematricula prematricula)
        {
            ComandoAprobarPrematricula comando = FabricaComando.CrearComandoAprobarPrematricula(prematricula);
            return comando.Ejecutar();
        }
        public List<SeccionMateria> ConsultarInformacionPrematricula (Prematricula prematricula)
        {
            ComandoConsultarInformacionPrematricula comando =
                FabricaComando.CrearComandoConsultarInformacionPrematricula(prematricula);
            return comando.Ejecutar();
        }

        public List<Estudiante> ConsultarEstudiantesConPrematricula()
        {
            ComandoConsultarEstudiantesConPrematricula comando =
                FabricaComando.CrearComandoConsultarEstudiantesConPrematricula();
            return comando.Ejecutar();
        }
        #endregion VU_13 Gestionar Horarios

        #region VU_14 Registrarse en Sistema

         public List<Universidad> ConsultarUniversidades()
        {
            Comando<List<Universidad>> miComando = FabricaComando.CrearComandoLlenarComboUniversidad();
            return miComando.Ejecutar();
        }

         

         public List<Universidad> ConsultarUniversidadesActivas()
         {
             Comando<List<Universidad>> miComando = FabricaComando.CrearComandoLlenarComboUniversidadesActivas();
             return miComando.Ejecutar();
         }

         public bool verificarCorreoUsuarioRol(String correo,int usuario)
         {
             if (usuario == 1)
             {
                 InicioSistema inicio = new InicioSistema();
                 return inicio.VerificarCorreo(correo);
                 
             }
             if (usuario == 2)
             {
                 InicioSistema inicio = new InicioSistema();
                 return inicio.VerificarCorreo(correo);
             }
             if (usuario == 3)
             {
                 InicioSistema inicio = new InicioSistema();
                 return inicio.VerificarCorreo(correo);
             }
             if (usuario == 4)
             {
                 InicioSistema inicio = new InicioSistema();
                 return inicio.VerificarCorreo(correo);
             }
             return false;
         }

         public bool verificarCedulaUsuarioRol(string nacionalidad,int cedula, int usuario)
         {
             
             if (usuario == 3)
             {
                 ControladorEstudiante rolActual = new ControladorEstudiante();
                 return rolActual.VerificarCedula(nacionalidad,cedula);
             }
             if (usuario == 4)
             {
                 
                 ControladorProfesor rolActual = new ControladorProfesor();
                 return rolActual.VerificarCedula(nacionalidad,cedula);
             }
             return false;
         }

         public bool verificarUsuarioRol(int cedula, int usuario)
         {
             if (usuario == 1)
             {
                 ControladorUniversidad rolActual = new ControladorUniversidad();
                 return rolActual.VerificarRol(cedula);

             }
             if (usuario == 2)
             {
                 ControladorEscuela rolActual = new ControladorEscuela();
                 return rolActual.VerificarRol(cedula);
             }
             if (usuario == 3)
             {
                 ControladorEstudiante rolActual = new ControladorEstudiante(); 
                 return rolActual.VerificarRol(cedula);
             }
             if (usuario == 4)
             {
                 ControladorProfesor rolActual = new ControladorProfesor();
                 return rolActual.VerificarRol(cedula);
             }
             return false;
         }
         public List<Escuela> ConsultarEscuelasCombo(int idUniversidad)
         {
             Comando<List<Escuela>> miComando = FabricaComando.CrearComandoLlenarComboEscuela(idUniversidad);
             return miComando.Ejecutar();
         }

         public void RegistrarRolenSistema(String correo, String clave,int usuario, int opcion)
         {
             if (usuario == 1)
             {
                 Rol rolActual = FabricaRol.CrearUniversidad();
                 rolActual.Correo = correo;
                 rolActual.Password = clave;
                 ControladorUniversidad miControl = new ControladorUniversidad();
                 miControl.RegistrarRol(rolActual, opcion);

             }
             if (usuario == 2)
             {
                 Rol rolActual = FabricaRol.CrearEscuela();
                 rolActual.Correo = correo;
                 rolActual.Password = clave;
                 ControladorEscuela miControl = new ControladorEscuela();
                 miControl.RegistrarRol(rolActual, opcion);
             }
             if (usuario == 3)
             {
                 Rol rolActual = FabricaRol.CrearEstudiante();
                 rolActual.Correo = correo;
                 rolActual.Password = clave;
                 ControladorEstudiante miControl = new ControladorEstudiante();
                 miControl.RegistrarRol(rolActual, opcion);
             }
             if (usuario == 4)
             {
                 Rol rolActual = FabricaRol.CrearProfesor();
                 ControladorProfesor miControl = new ControladorProfesor();
                 rolActual.Correo = correo;
                 rolActual.Password = clave;
                 miControl.RegistrarRol(rolActual, opcion);
             }
         }
            

        
        #endregion VU_14 Registrarse en Sistema

        #region VU_15 Gestionar de Acceso

       
        public int UsuarioActualEscuela(string nick, string pass)
        {
            ComandoVerificarUsuarioRolEscuela comando = 
                FabricaComando.CrearComandoVerificarUsuarioRolEscuela(nick,pass);
            return comando.Ejecutar();
        }

        public int UsuarioActualUniversidad(string nick, string pass)
        {
            ComandoVerificarUsuarioRolUniversidad comando =
                FabricaComando.CrearComandoVerificarUsuarioRolUniversidad(nick, pass);
            return comando.Ejecutar();
        }

        public int UsuarioActualEstudiante(string nick, string pass)
        {
            ComandoVerificarUsuarioRolEstudiante comando =
                FabricaComando.CrearComandoVerificarUsuarioRolEstudiante(nick, pass);
            return comando.Ejecutar();
        }

        public int UsuarioActualProfesor(string nick, string pass)
        {
            ComandoVerificarUsuarioRolProfesor comando =
                FabricaComando.CrearComandoVerificarUsuarioRolProfesor(nick, pass);
            return comando.Ejecutar();
        }

        public Escuela CargarUsuarioDeEscuela(int escuelaActual)
        {
            ComandoCargarUsuarioDeEscuela comando = 
                FabricaComando.CrearComandoCargarUsuarioDeEscuela(escuelaActual);
            RolActual = comando.Ejecutar();
            return (Escuela)RolActual;
        }

        public Universidad CargarUsuarioDeUniversidad(int uniActual)
        {
            ComandoCargarUsuarioDeUniversidad comando =
                FabricaComando.CrearComandoCargarUsuarioDeUniversidad(uniActual);
            RolActual = comando.Ejecutar();
            return (Universidad)RolActual;
        }

        public Profesor CargarUsuarioDeProfesor(int Prof)
        {
            ComandoCargarUsuarioDeProfesor comando =
                FabricaComando.CrearComandoCargarUsuarioDeProfesor(Prof);
            RolActual = comando.Ejecutar();
            return (Profesor)RolActual;
        }

        public Estudiante CargarUsuarioDeEstudiante(int Est)
        {
            ComandoCargarUsuarioDeEstudiante comando =
                FabricaComando.CrearComandoCargarUsuarioDeEstudiante(Est);
            RolActual = comando.Ejecutar();
            return (Estudiante)RolActual;
        }

        
        #endregion VU_15 Gestionar de Acceso

        #region VU_16 Gestionar Estudiante

        public bool verificarCedulaEstudianteAgregar(int cedula)
        {
            return new ControladorEstudiante().VerificarCedulaEstudiante(cedula);
        }

        public bool verificarExpedienteEstudianteAgregar(string expediente, int escuela)
        {
            return new ControladorEstudiante().VerificarEspedienteEstudiante(expediente, escuela);
        }

        public bool AgregarEstudianteEnSistema(string nombre, string apellido, string sexo, int cedula, string expediente,
            DateTime fecha, string correo, string telefono,string nacionalidad,int escuela)
        {
            Estudiante miEstudiante = new Estudiante(nombre,apellido,sexo,nacionalidad,cedula,expediente,fecha,correo,telefono);
            Comando<bool> comando = FabricaComando.CrearComandoAgregarEstudiante(miEstudiante, escuela);
            return comando.Ejecutar();
        }

        public Estudiante BuscarEstudianteCedula(int cedula, int escuela)
        {
            Comando<Estudiante> comando = FabricaComando.CrearComandoBuscarEstudianteCedula(cedula, escuela);
            return comando.Ejecutar();
        }

        public Estudiante BuscarEstudianteExpediente(int expediente, int escuela)
        {
            Comando<Estudiante> comando = FabricaComando.CrearComandoBuscarEstudianteExpediente(expediente, escuela);
            return comando.Ejecutar();
        }
        #endregion
        #region Usuarios
        public Profesor EnlaceCrearProfesor()
        {
            Rol profesor = FabricaRol.CrearProfesor();
            return (Profesor)profesor;
        }

        public Escuela EnlaceCrearEscuela()
        {
            Rol escuela = FabricaRol.CrearEscuela();
            return (Escuela)escuela;
        }

        public Universidad EnlaceCreaUniversidad()
        {
            Rol universidad= FabricaRol.CrearUniversidad();
            return (Universidad)universidad;
        }

        public Estudiante EnlaceCrearEstudiante()
        {
            Rol estudiante = FabricaRol.CrearEstudiante();
            return (Estudiante)estudiante;
        }

        #endregion

        public List<SeccionMateria> ConsultarMateriaEstudiantePeriodo(Estudiante estudiante)
        {
            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarMateriaEstudiantePeriodo(estudiante);
            return comando.Ejecutar();
        }

        public List<SeccionMateria> ConsultarMateriaEscuelaPeriodo(Escuela escuela)
        {

            Comando<List<SeccionMateria>> comando = FabricaComando.CrearComandoConsultarMateriaEscuelaPeriodo(escuela);
            return comando.Ejecutar();
        }
    }
}